Esta pregunta ya tiene respuestas aquí:
Sin conversión implícita en el operador sobrecargado
(2 respuestas)
Cerrado hace 7 años.
Estoy escribiendo un contenedor simple para un tipo elemental y estoy tratando de evitar tener que escribir demasiados tipos de operadores estándar. Esperaba que la conversión de tipos implícita ayudara, pero no es así. Aquí hay un ejemplo simplificado:
estructura Int
{
int _i;
Int (int i = 0): _i {i} {}
Int operador + (const Int & rhs) {return _i + rhs._i;}
};
int main (int argc, char * argv [])
{
(vacío) (Int (1) + 2); // Multa
(vacío) (2 + Int (1)); // error: operandos no válidos para la expresión binaria ('int' e 'Int')
}
Estoy usando llvm. La primera línea de main se compila bien. El segundo provoca un error. Ahora, lo que esperaba que sucediera en la segunda línea es que 2 se convertiría implícitamente en Int (2), seguido de una llamada al operador +. ¿Por qué no está pasando eso? ¿Por qué ocurre la conversión implícita en la primera línea?
2021-03-01 08:20:11
Ocurre en la primera línea porque el único operador + disponible es operator + (Int &) (que tiene un primer parámetro implícito de Int para esta instancia). La segunda línea falla porque el primer parámetro es un int y no tiene idea de que necesita convertirlo antes de intentar la operación (no sabe que necesita usar Int :: operator +).
Puede evitar ese problema convirtiendo al operador en una función de amigo no miembro (http://ideone.com/YCf7wX)
estructura Int
{
int _i;
Int (int i = 0): _i {i} {}
amigo Int operador + (const Int & lhs, const Int & rhs);
};
Int operador + (const Int & lhs, const Int & rhs)
{
return lhs._i + rhs._i;
}
int main ()
{
Int i;
i + 5;
5 + i;
return 0;
}
|
No es la respuesta que estás buscando? Explore otras preguntas etiquetadas c ++ operator-keyword implicit-conversion o haga su propia pregunta